/*
 * Copyright 2008-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.fsquare.controller.cart;


import org.apache.commons.lang3.StringUtils;
import org.broadleafcommerce.common.money.Money;
import org.broadleafcommerce.core.catalog.domain.Product;
import org.broadleafcommerce.core.catalog.domain.ProductOption;
import org.broadleafcommerce.core.catalog.domain.ProductOptionXref;
import org.broadleafcommerce.core.order.domain.DiscreteOrderItem;
import org.broadleafcommerce.core.order.domain.NullOrderImpl;
import org.broadleafcommerce.core.order.domain.Order;
import org.broadleafcommerce.core.order.domain.OrderItem;
import org.broadleafcommerce.core.order.service.exception.AddToCartException;
import org.broadleafcommerce.core.order.service.exception.ProductOptionValidationException;
import org.broadleafcommerce.core.order.service.exception.RemoveFromCartException;
import org.broadleafcommerce.core.order.service.exception.RequiredAttributeNotProvidedException;
import org.broadleafcommerce.core.order.service.exception.UpdateCartException;
import org.broadleafcommerce.core.pricing.service.exception.PricingException;
import org.broadleafcommerce.core.web.controller.cart.BroadleafCartController;
import org.broadleafcommerce.core.web.order.CartState;
import org.broadleafcommerce.core.web.order.model.AddToCartItem;
import org.broadleafcommerce.profile.core.domain.Customer;
import org.broadleafcommerce.profile.web.core.CustomerState;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.fsquare.inventory.domain.SkuInventory;
import com.fsquare.inventory.service.InventoryService;
import com.fsquare.inventory.service.InventoryUnavailableException;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Controller
@RequestMapping("/cart")
public class CartController extends BroadleafCartController {
	
	@Resource(name = "fsquareInventoryService")
    protected InventoryService inventoryService;
	
    @Override
    @RequestMapping("")
    public String cart(HttpServletRequest request, HttpServletResponse response, Model model) throws PricingException {
        String ret = super.cart(request, response, model);
        String insuficientInventory = request.getParameter("insuficientInventory");
        if(insuficientInventory != null && !insuficientInventory.equals(""))
        	 model.addAttribute("insuficientInventory", insuficientInventory);
        
        Map<Long, Integer> inventoryMap = getInventoryMap();
        model.addAttribute("inventoryMap", inventoryMap);
        
        return ret;
    }
    
    /*
     * The Heat Clinic does not show the cart when a product is added. Instead, when the product is added via an AJAX
     * POST that requests JSON, we only need to return a few attributes to update the state of the page. The most
     * efficient way to do this is to call the regular add controller method, but instead return a map that contains
     * the necessary attributes. By using the @ResposeBody tag, Spring will automatically use Jackson to convert the
     * returned object into JSON for easy processing via JavaScript.
     */
    @RequestMapping(value = "/add", produces = "application/json")
    public @ResponseBody Map<String, Object> addJson(HttpServletRequest request, HttpServletResponse response, Model model,
            @ModelAttribute("addToCartItem") AddToCartItem addToCartItem) throws IOException, PricingException, AddToCartException {
        Map<String, Object> responseMap = new HashMap<String, Object>();
        try {
            super.add(request, response, model, addToCartItem);
            
            if (addToCartItem.getItemAttributes() == null || addToCartItem.getItemAttributes().size() == 0) {
                responseMap.put("productId", addToCartItem.getProductId());
            }
            
            Product product = catalogService.findProductById(addToCartItem.getProductId());
            Order cart = CartState.getCart();
            
            OrderItem orderItem = null;
            for(OrderItem item: cart.getOrderItems()){
            	if(((DiscreteOrderItem)item).getProduct().getId().equals(product.getId()))
            		orderItem = item;
            }
            Money price = orderItem.getPriceBeforeAdjustments(true);
            responseMap.put("productPrice", price.getAmount().toString()+" EUR");
            
            responseMap.put("productURL", product.getUrl());
            responseMap.put("productImage", product.getMedia().get("primary"));
            responseMap.put("productName", product.getName());
            responseMap.put("quantityAdded", addToCartItem.getQuantity());
            responseMap.put("cartItemCount", String.valueOf(CartState.getCart().getItemCount()));
            if (addToCartItem.getItemAttributes() == null || addToCartItem.getItemAttributes().size() == 0) {
                // We don't want to return a productId to hide actions for when it is a product that has multiple
                // product options. The user may want the product in another version of the options as well.
                responseMap.put("productId", addToCartItem.getProductId());
            }
            List<String[]> productOptionDisplayValues = new ArrayList<String[]>();
            for (String i : orderItem.getOrderItemAttributes().keySet()) {
                for (ProductOptionXref productOptionXref : product.getProductOptionXrefs()) {
                	ProductOption option = productOptionXref.getProductOption();
                    if (option.getAttributeName().equals(i) && !StringUtils.isEmpty(orderItem.getOrderItemAttributes().get(i).toString())) {
                    	productOptionDisplayValues.add(new String[]{option.getLabel(), orderItem.getOrderItemAttributes().get(i).toString()});
                    }
                }
            }

            responseMap.put("productOptions", productOptionDisplayValues);
            
            
        } catch (AddToCartException e) {
            if (e.getCause() instanceof RequiredAttributeNotProvidedException) {
                responseMap.put("error", "allOptionsRequired");
            } else if (e.getCause() instanceof ProductOptionValidationException) {
                ProductOptionValidationException exception = (ProductOptionValidationException) e.getCause();
                responseMap.put("error", "productOptionValidationError");
                responseMap.put("errorCode", exception.getErrorCode());
                responseMap.put("errorMessage", exception.getMessage());
                //blMessages.getMessage(exception.get, lfocale))
            } else {
                throw e;
            }
        }
        
        return responseMap;
    }
    
    /*
     * The Heat Clinic does not support adding products with required product options from a category browse page
     * when JavaScript is disabled. When this occurs, we will redirect the user to the full product details page 
     * for the given product so that the required options may be chosen.
     */
    @RequestMapping(value = "/add", produces = { "text/html", "*/*" })
    public String add(HttpServletRequest request, HttpServletResponse response, Model model, RedirectAttributes redirectAttributes,
            @ModelAttribute("addToCartItem") AddToCartItem addToCartItem) throws IOException, PricingException, AddToCartException {
        try {
            return super.add(request, response, model, addToCartItem);
        } catch (AddToCartException e) {
            Product product = catalogService.findProductById(addToCartItem.getProductId());
            return "redirect:" + product.getUrl();
        }
    }
    
    @RequestMapping("/updateQuantity")
    public String updateQuantity(HttpServletRequest request, HttpServletResponse response, Model model, RedirectAttributes redirectAttributes,
            @ModelAttribute("addToCartItem") AddToCartItem addToCartItem) throws IOException, PricingException, UpdateCartException, RemoveFromCartException {

    	String skuId = request.getParameter("skuId");
    	SkuInventory skuInventory = inventoryService.getInventory(Long.parseLong(skuId));
    	Map<Long, Integer> inventoryMap = getInventoryMap();
        model.addAttribute("inventoryMap", inventoryMap);
    	if(skuInventory.getQuantityAvailable() < addToCartItem.getQuantity()) {
			
			if (isAjaxRequest(request)) {
	            Map<String, Object> extraData = new HashMap<String, Object>();
//	            extraData.put("insuficientInventory", addToCartItem.getSkuId());
//	            extraData.put("cartItemCount", cart.getItemCount());
	            model.addAttribute("insuficientInventory", addToCartItem.getSkuId());
	            model.addAttribute("blcextradata", new ObjectMapper().writeValueAsString(extraData));
	            return getCartView();
	        }else {
	        	return getCartPageRedirect()+"?insuficientInventory="+addToCartItem.getSkuId();
			}
		}

    	return super.updateQuantity(request, response, model, addToCartItem);
    	
    }
    
    @Override
    @RequestMapping("/remove")
    public String remove(HttpServletRequest request, HttpServletResponse response, Model model,
            @ModelAttribute("addToCartItem") AddToCartItem addToCartItem) throws IOException, PricingException, RemoveFromCartException {
        return super.remove(request, response, model, addToCartItem);
    }
    
    @Override
    @RequestMapping("/empty")
    public String empty(HttpServletRequest request, HttpServletResponse response, Model model) throws PricingException {
        //return super.empty(request, response, model);
        return "ajaxredirect:/";
        
    }
    
    @Override
    @RequestMapping("/promo")
    public String addPromo(HttpServletRequest request, HttpServletResponse response, Model model,
            @RequestParam("promoCode") String customerOffer) throws IOException, PricingException {
        return super.addPromo(request, response, model, customerOffer);
    }
    
    @Override
    @RequestMapping("/promo/remove")
    public String removePromo(HttpServletRequest request, HttpServletResponse response, Model model,
            @RequestParam("offerCodeId") Long offerCodeId) throws IOException, PricingException {
        return super.removePromo(request, response, model, offerCodeId);
    }
    
    private Map<Long, Integer> getInventoryMap(){
		Map<Long, Integer> inventoryMap = new HashMap<Long, Integer>();
		Order cart = CartState.getCart();
		if (cart != null && !(cart instanceof NullOrderImpl)) {
        	List<OrderItem> items = cart.getOrderItems();
        	if(items != null) {
    	    	for(OrderItem item : items) {
    	    		if(item instanceof DiscreteOrderItem) {
    	    			SkuInventory skuInventory = inventoryService.getInventory(((DiscreteOrderItem)item).getSku());
    	    			inventoryMap.put(item.getId(), skuInventory.getQuantityAvailable());
    	    		}    		
    	    	}
        	}
            
        }
		return inventoryMap;
	}
    
}
